﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Djs.Neuronic.UI
{
    public class PicLibrary
    {
        #region Image CrossBlue
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossBlue.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossBlue_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossBlue, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossBlue_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossBlue.png
        /// </remarks>
        public static System.Drawing.Image CrossBlue_Cached
        {
            get
            {
                if (_CrossBlue == null) _CrossBlue = CrossBlue;
                return _CrossBlue;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossBlue.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossBlue_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossBlue_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossBlue_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossBlue.png
        /// </remarks>
        public static System.Drawing.Image CrossBlue { get { return _ImageCreateFrom(_CrossBlue_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossBlue.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossBlue_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossBlue_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossBlue.png
        /// </remarks>
        public static System.Drawing.Image CrossBlue_FromFile { get { return _ImageCreateFrom(_CrossBlue_string, "CrossBlue.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossBlue
        /// </summary>
        /// <returns></returns>
        private static string _CrossBlue_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1524);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAOmSURB");
            sb.Append("VFhHxZdLSFRhFMfH6SFpTi3yBfZYmI4DGbSKhLHcaJb2oBdoZGFBQ2KCKFQ2oZa1iYIoIauFGG2KahPkoiB7gUlFpJgFBTO20ZhRF2rO6f5u87hO85KmrjAwzj3n9z/3");
            sb.Append("fOec7/sSDJq/bL4bjTnzk5ObFiQv3mZMTEyRGc+rKbfr4IDbNaC1jfbdbDKZF5qW3kqYZ1zvmZwcm54Yf/BzYqLF4PEMDoVyRjwnMdGWn7VcNhRYpWj7LimuqJLiyiop");
            sb.Append("KCxyWlLTzdFEfc+xxQdfGLBgwkZDfdHgN89dlGRbtzpXNpaWS2n1UdnZcEr2Np+XfW0XZbf9nFg3lzktadGDwAZbfPCFAQsmbDRyk5ICQfjenAebynZIma1W9pxpk/2X");
            sb.Append("2+XQjS6p7rorh2/fk4pL7d4gMsJmwpKWoYpjiw++MGDBhI0GWv5MZCtrTmqIDoO9LRfkwNWbKsD2sFtqunuk9slrqXncI5VXrhOEQxHKC84iv/EMG2xVH8UXBiyYsNFA");
            sb.Append("C020DeaUlE7WhxQRJYZH7tyXY4+eSt2zN1Lf2y+N7z9L44cvcrynLxBEeiAIi/LdJ44NtvjgCwMWTNhooIUm2oY1GZluioR1IlVEq4o/75OGd5/kxKBDmr6OyGmHS5q+");
            sb.Append("jUrdi7eaIDLzLOmZfnGeYaPaKj74woAFEzYaaKGJtmHtylVqpVIsrBcpI2ocTw4Ni93pkubRKWl1zUir2yP27+P+IApLyx18SDviPMMGW3zsTrfKUINQmLDRQAtNtA35");
            sb.Append("WSte0i5ULEXDutX3flSjB9DyY1rOjsmsTyCIDiUbHX7xYDt8YcCCCRsNtNBE22A2LVF7lrYhRRQP60cKeYtgqO9/XxDqmw+Ph7WDAQsmbDTQQhNttZgty9LM1pKtSvtc");
            sb.Append("UyuYImIdSWW4APidIPhEsoEBCyZsNKwlykwJHmyWVCUIpYdZTyqZYmI9I8FjeQYDlqaDwk9VovK1U7TUxiLuy9Kszok2TbUD5W+D0HZMuAEWcn+JRxB/iGsGV0ybGtPt");
            sb.Append("d4+Hb7NoHYIvDIZVTKJaI10D0HUJ4iEePKwi7aKzlsZ7mAjM9ggTLu5t6J0BmkE0EsdBNBJ5EKni/20UKycr7SjWfTMKvR33z307DlEvMW3H0Q8k7n97INH9SKbvodTU");
            sb.Append("adD9WK77xYRRSBBclyJezejdaIcJjnfemRJ8NdsS7mrmm8W6Xk61QVATFCbdQYsyJ/yn1zls6lzP8YUBCybs4JvxL3ksSVZ3oljGAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossBlue_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossBlue_Reset()
        {
            _CrossBlue = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossBlue_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossBlue = null;
        #endregion
        #region Image CrossGray
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossGray.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossGray_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossGray, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossGray_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossGray.png
        /// </remarks>
        public static System.Drawing.Image CrossGray_Cached
        {
            get
            {
                if (_CrossGray == null) _CrossGray = CrossGray;
                return _CrossGray;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossGray.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossGray_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossGray_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossGray_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossGray.png
        /// </remarks>
        public static System.Drawing.Image CrossGray { get { return _ImageCreateFrom(_CrossGray_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossGray.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossGray_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossGray_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossGray.png
        /// </remarks>
        public static System.Drawing.Image CrossGray_FromFile { get { return _ImageCreateFrom(_CrossGray_string, "CrossGray.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossGray
        /// </summary>
        /// <returns></returns>
        private static string _CrossGray_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1416);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAANVSURB");
            sb.Append("VFhHxZdPSJNxGMffJilT58nhQfS0xCKoUymxU+BAkE6BtybBDl4CD13mPBidXIp0kUImRqckECQ0nCK0SiZkiCSjVAI1502ZIuGe3s9r73z3uj+vNHpfeNn2/p7n+/3u");
            sb.Append("+ff+fpcUw+VRvzscjiZnZWXIWVV173JFhSt9cvI5tb/ftXxwsGa0Lfb9psvVXFVTE3GUlbX8Pj4+OEqlJo8OD5+k0+nE91zOV9SH18rLu+/U18v91lYJdHTIo85O7e70");
            sb.Append("erdv1dY2FyPV17HFR/cHC0yw4YAr6+LBdaez+67HI10+nzz2++VpT48MhkLyvL9fwsGg+NvaLImA/IFqiw++YIAFJthwwJURQdhRxcLD9nYJBgLyrLdXXobD8npkRN5E");
            sb.Append("IjIxNiYvBgZORbjdeSPBGjbY4oMvGGCBCTYccMEJt9Kk5pzQoA6Dob4+iQwPawDvJiYkOjUlCzMz2ufo4CAitm673VfNUeQZa9gYfcAAC0yw4YALTriVG9XVr8gPIUIl");
            sb.Append("hm/Hx+X95KR8mJ2VeCwmy/G4fF1aklg0mlOEkRwbbPHBFwywwAQbDrjghFtpqavbp0jIE6FCLQ6xuTn5srgo31ZW5EciIZvr69rnx/n5LBFGctaMtviCARaYYMMBF5xw");
            sb.Append("K96GBq3SKRbyRchQjePa6qpGvLO9LcndXUkmk/Jzc/NMhM+35Vdvwg45a9hgiw++YIAFJthwwAUn3Iqai0/8oGIpGvJH6FAPwK+dHdnb28u6MyKGhmRUvXVysx2+YIAF");
            sb.Append("JthwwAUn3AoDg56lbQjRwvS0lj9Cyb8wg+q/dRH5yHU7MMACE2w44IITbq2Y9d6lfVBJEaGcUOYTwHNEcBeyAQMsMMHOtLN5sCGCHiafVDKqyWchcCtrYIBl6KD8A+3v");
            sb.Append("IDkrqo2NfxaQVbTqnCg0yLR0mNuqWIiLpcjctpbeJ6UQYf7nuaZnQTGaCHq8QJsV6xB8wbgweSYVdgmwNQWlIDcPq0Jv0aw6ONeGRYaMlTlguQ1tHUQ6uS2j+L++jNSd");
            sb.Append("1bmXke2vY1s3JI2NYv+WzPZNqe3b8oseTNRJWdqDCaOw1EczdlaWj2b6LLb1cKqLIB3UBIXJocGrtglzIrN7tbSdOTXCB18wwAITbO08aLj+AA8655eBGzVSAAAAAElF");
            sb.Append("TkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossGray_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossGray_Reset()
        {
            _CrossGray = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossGray_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossGray = null;
        #endregion
        #region Image CrossGreen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossGreen.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossGreen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossGreen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossGreen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossGreen.png
        /// </remarks>
        public static System.Drawing.Image CrossGreen_Cached
        {
            get
            {
                if (_CrossGreen == null) _CrossGreen = CrossGreen;
                return _CrossGreen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossGreen.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossGreen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossGreen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossGreen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossGreen.png
        /// </remarks>
        public static System.Drawing.Image CrossGreen { get { return _ImageCreateFrom(_CrossGreen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossGreen.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossGreen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossGreen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossGreen.png
        /// </remarks>
        public static System.Drawing.Image CrossGreen_FromFile { get { return _ImageCreateFrom(_CrossGreen_string, "CrossGreen.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossGreen
        /// </summary>
        /// <returns></returns>
        private static string _CrossGreen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1576);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAPNSURB");
            sb.Append("VFhHxZdNSFRRFMfHcRxLU1ulopaLrLEYCEexlCTKFpGfYCMlYilGCdGqlRpEoEkQbUqhSKgkUIqEapELw4QUS4Kgoq+dtirQLPKjOd3fs5l5b5wvxcmBCzPzzvn//+/c");
            sb.Append("c849N8qk+2xV36PMpm3r4i2tsRtiymNizQkul4z8mpo78WZq4b3eNtR3e6LFFrfR2m02R+2en3X9mJ2Z7//9c+GiuEwfPvlzhtwWa27Kz4iTkqJkqanKlIbjWdoq358y");
            sb.Append("mZNstYUidT/HFh+3P1hggg0HXIYPf+yIi27auz1RnGUZcuq0Tc617JLWS3ly4Uq+NLc55Ehp+qQjDBHYYIsPvmCABSbYcMDlEeF+cx4crdwiZ87ulJb2XLnUVShXe/bJ");
            sb.Append("tfsH5PqDYmnrKhAnIlJiA0bCkWK1YYMtPviCARaYYMMBlycSWWrPCQ3qMDjfkSeXbxVpAN0Dh6RnuFTujZbL3eES6bhRiIgJJSLbN4qKPJtn2GCLD75ggAUm2HDABSfc");
            sb.Append("JnuC5Q77Q4hQiWHnw4Ny+9lh6X1VIf3vquTx52p58qVaescrdCKsHhF6cmywxQdfMMACE2w44IITblNu6vppkoR9IlSoxaFvvFIefXTK04ljMvitVoam6mTwe630vdaJ");
            sb.Append("SLVmO9RyvznPsNFslQ++YIAFJthwwAUn3KY9mfFSrzKdZGG/CBmqcRz4WqOBjczVy9ifRhlzNcrzmTqviLL0CadahB1ynmGDLT5D03UaBlhggg0HXHDCbcrfHPeCciFj");
            sb.Append("SRr2rf9tlaYegNH5BnkpJw3LI+JmoXSo5Sb3tcMXDLDABBsOuOCE22RPitZqlrIhRCQP+0cIeQtfUPfvRRGV2uJ7IDswwAITbDia23K13mJPsixWVM4mVbslaZNtnQVa");
            sb.Append("BpNEhJ5QBgLmf4iDkWMDBlhggt2uOOgTSxqbQ4lwlqZNsp9kMsnEfgYTEM4zMMDSVVDghkYXUyIMSRUOSagoGSonOXAj07ZDX9OBkitcUYaKCdDA/J4vqyFixeRuRZoI");
            sb.Append("alwrs+CZ7r9MK7USBcORurR1hzxZ11TA6m2BikKQAyxi++/brMIWEbky1EUiUBn+I/c2ItU+V60RKaygjYi2SCumTUa8FatpydCKORD+/2Hk8B5GxuO4ePE4VpNM5I7j");
            sb.Append("YuNxHHIgUed5JAYS5gFtIFn+SKbL6NUYydZ0KE1UQ+nKxnLvRGw4O1Yylod7MWmP1MWENwh9Nctd3tVM9RR/V7Nqf1czdwjX9HKqF0FOkJhUB2VCn/BMryEPca8B13N8");
            sb.Append("wQALTLB9b8Z/AQattBbrcQZZAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossGreen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossGreen_Reset()
        {
            _CrossGreen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossGreen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossGreen = null;
        #endregion
        #region Image CrossPink
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossPink.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossPink_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossPink, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossPink_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossPink.png
        /// </remarks>
        public static System.Drawing.Image CrossPink_Cached
        {
            get
            {
                if (_CrossPink == null) _CrossPink = CrossPink;
                return _CrossPink;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossPink.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossPink_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossPink_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossPink_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossPink.png
        /// </remarks>
        public static System.Drawing.Image CrossPink { get { return _ImageCreateFrom(_CrossPink_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossPink.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossPink_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossPink_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossPink.png
        /// </remarks>
        public static System.Drawing.Image CrossPink_FromFile { get { return _ImageCreateFrom(_CrossPink_string, "CrossPink.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossPink
        /// </summary>
        /// <returns></returns>
        private static string _CrossPink_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1440);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAANnSURB");
            sb.Append("VFhHxZdPSFRRFMbfOE4zDg6414V/UmwgaVZqaoaY4EJnI2rqgCmNNikoSjtXrtuai6JFCNGqVtm6hVFQkAQhUbSw2hTVQGSTnu7v4R3fvObNMzXfMJeZefec7/vm3nPP");
            sb.Append("PcdnWF4n1fciw6gLBwILasRP+P2RHZEn6a2tSy8ymddWW7fvsUCgPhIM3i7y+Zp+bW+nf2QyD9RY3DGMjTf5nGvVw6jfn2orLZWL5eVytbZWrkWj5khUVHxoCoXq3Uj1");
            sb.Append("PLb4aH+wwAQbDrhyXjw4XVyculBWJsnqalloaJDrjY2y3Noqt9rbZamlRS5XVu5LBOTY4oMvGGCBCTYccGVFsOyoYuJKTY0sxmKypJxWOjvlfne3POzpkVU1Vjo6JOki");
            sb.Append("AnJssMUHXzDAuqEwwYYDLjjhNurUm6VBHQbLbW1yr6tLVnt75XFfnzwbHJTnQ0PydGBA7iogRbDZHAqdsq8iz5jDBlt88AUDLDDBhgMuOOE2zgQCd9gflgiVGD6Kx2Wt");
            sb.Append("v19ejozIxuiovBsfl/dqrA8P5xVhJccGW3zwBQMsMMGGAy444TbOhsPfCRL2iaVCLQ7riYS8HRuTjxMT8jmVkq9TU/JFfb5SgNaVsJIzp235xBcMsMAEGw644ITbOB+J");
            sb.Append("mJFOsLBfLBmqcfw0OSnfFPHPmRnJzM2ZIz09vSeiqmozqQaCIGdO2+GDLxhggQk2HHDBCbeh9mKNHzdVxBI07BtLh3oAtmZn5ff8fM6wirCS2+3wBQMsMMGGAy44zylu");
            sb.Append("g4TBmeXYELkED/vHEvIv7KD6txah/7mTHRhggQk2HHDBCbcZzE3BoHl2OT5EMEHEnrOcTsA8RwSjkA0YYIEJNhx5cwoiOMMsKZGMajcBhYj1HBgEr+UEOSe0XRE5QbUf");
            sb.Append("ErdVsp4c15RuP1ZuS/wv5PkSWN775ShE5BxXh+xZ8HI7jAh7rmguKfkrdbverJ4KOAy5PU8UusD+2/4fWISnx9CeiEgex5aIdBnlSSr2/DLS1zEF5HFdx3Blr2PPCxLK");
            sb.Append("oql9lmTckEdVksFplmSeF6Wel+W6MemyNCaUzk6NiUrTji3agRoT8rFuzRDh1Jq5dUXZvnC3vHNqzeDIac20o6fNqRbBdhATBCYRyhGldM5Wr66X+J4BPviCARaYYJv9");
            sb.Append("oOX1B+qAELGcLsORAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossPink_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossPink_Reset()
        {
            _CrossPink = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossPink_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossPink = null;
        #endregion
        #region Image CrossRed
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossRed.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossRed_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossRed, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossRed_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossRed.png
        /// </remarks>
        public static System.Drawing.Image CrossRed_Cached
        {
            get
            {
                if (_CrossRed == null) _CrossRed = CrossRed;
                return _CrossRed;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossRed.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossRed_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossRed.png
        /// </remarks>
        public static System.Drawing.Image CrossRed { get { return _ImageCreateFrom(_CrossRed_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossRed.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossRed.png
        /// </remarks>
        public static System.Drawing.Image CrossRed_FromFile { get { return _ImageCreateFrom(_CrossRed_string, "CrossRed.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossRed
        /// </summary>
        /// <returns></returns>
        private static string _CrossRed_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1412);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAANQSURB");
            sb.Append("VFhHxZdNSBRhGMf/rraSYdcCizqkaBEoGukKIrQFUWJCFBgVFSkseO4UHereNTrUoUMQXepWdI3qEBH0RRT0QUJ0qTY8qOzT+5t13JlxZ0Ztc4cddj6e5/9/5vl83wYF");
            sb.Append("jh3uOiN1tKjpYovWjWaVaS3JnhY1e+aF5t8FZdOue9TU2arszYwa+mdVKs5o7t6M5i+XpPcfqim3u4c7lSkMqcXGtcmmtN0uqN07T2nz9ICynWmk/ntk0fH1wQITbDjg");
            sb.Append("Ch082K3GwgFttElttUvqtKvqtuvaYze0166p1z3fsiwjIEcWHXTBAAtMsOGAa9EI3I5VvChom13RLkfYZ7c1aPc1bA+0zx4q7+5zC0Y0x3rCJ0cWHXTBAAtMsOGAC064");
            sb.Append("1eF+uAbrEMDiuxryAB7roD3XiL3UqPs/bHcckPu6bzk1d0W9mFO2i3fIIFvWGfEwwAITbDjgghNudavpFvHBRViJ4CPtt2c6ZK90xD7qqH3RcfvqztfuvmJEdtGIIDky");
            sb.Append("yKKDLhhggQk2HHDBCbdyWv+bJCFOuAprUXijMfukY/Zd4/ZTJ62o0/bL/b+NGBEk5x0yyKKD7meHARaY5VAOelxwwq1hbfAyHfcQL1yG1Sj+0An748DmdNZKOu+dM+4+");
            sb.Append("aITvdp7xzpdDB10wwAITbDjgghNuuVg84YaMJWmIG67DegDmdc5ME6EzaAQh8cmjcuiCARaYYMMBF5xwq0eNXs1SNriI5CF+uJCviIL692UjxryT6zg5MMACE2w4yAM4");
            sb.Append("aVZeMve72p1Q2zTlQwaTRMQRd8YB8xziJHJkwAALTLAr5RxpbBgx6YzApWQyyZRmQJJx/jswwApUUHxDKzeSNq+W4+K6HNKgTDRpBxTfyLxwRMsqzcVpIQqX7dIGVnW+");
            sb.Append("1MKI6JdX656Jwy1sRHKmVy/TscTWnTpZ62pA7UKwCi/UgjzarJKmaCgU/68MK56ILcMF8vo0Isjr1ooZCGs/jHorwyg8jvNrMI7z4XFc9wVJ0pKMlczSJVmwtrNd/7wk");
            sb.Append("q/uidHXL8sqK2G8kq16Wr3Rj4qZabTcmfEH61qxvRVszesqyt2a+C+u6OfWNIBzkBIlJdVCi9InF1WvqEK8IoIMuGGCBCba3HwwcfwFcCARy9NoYkwAAAABJRU5ErkJg");
            sb.Append("gg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossRed_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossRed_Reset()
        {
            _CrossRed = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossRed_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossRed = null;
        #endregion
        #region Image CrossYellow
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossYellow.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossYellow_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossYellow, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossYellow_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossYellow.png
        /// </remarks>
        public static System.Drawing.Image CrossYellow_Cached
        {
            get
            {
                if (_CrossYellow == null) _CrossYellow = CrossYellow;
                return _CrossYellow;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossYellow.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossYellow_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossYellow.png
        /// </remarks>
        public static System.Drawing.Image CrossYellow { get { return _ImageCreateFrom(_CrossYellow_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossYellow.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\CrossYellow.png
        /// </remarks>
        public static System.Drawing.Image CrossYellow_FromFile { get { return _ImageCreateFrom(_CrossYellow_string, "CrossYellow.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossYellow
        /// </summary>
        /// <returns></returns>
        private static string _CrossYellow_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1568);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAPFSURB");
            sb.Append("VFhHxZdLSFRhFMev4zRDY2qrHFHLRZoWgaKSjiBSFkSOD5AEw+yBSkK0bFO0KKw2tUwsbBEhSEW167FoUZQLraA0KqMHGhFFoyakNqfvd6fr3NF5KTM6cJmZe8/5/889");
            sb.Append("7y9BM302qt8Wi5brSLKedKxZVWuzW5K9Xnk24Zk++Nwz+8YsG+l3YYo1L3mt7arFklA6/cc7MTU5c2fq9+xpr1d7+z6Yco66udlu6ajIckhTRZocbciW4wdy9Gv/dudY");
            sb.Append("WZotLxKp8RxZdAx9sMAEGw64Aj7c2OpI7Ni1KUXaa7Lk1JE8uXiiQLrPlUjPhW3S1Vkk7e7MqIyAHFl00AUDLDDBhgOuOSNwO1bxoKN+g5w5tkW6zhZLb1e53L1eKfdu");
            sb.Append("7pD7t6rUf5fPCKc9pCfKnD5yZNFBFwywwAQbDrjghFvLVTHHNViHQPf5ErnRU6EDPHmwWwYeu+Vlf636rpa+y+UYMepy2vPne9HltOXzDBlkfTpuHQMsMMGGAy444dYK");
            sb.Append("kq3XiA8uwkoEH97eKf2P9sirgToZGW6QzyON8uVDo7werDMZYZszwkyODLLooAsGWGCCDQdccMKtudJXj5MkxAlXYS0KQ4P18vHdXvk22iS/fjTLhKdFPD+bZfiFyYh0");
            sb.Append("W75LXcab8wwZZNFB95PCAAtMXyjLdS444dYqs5P0TCdZiBcuw2oUv3/dJ5MKbGb6kHj/torX2ypTky1+I2oyR9vVhdsh5xkyyKIzOd6iY4AFJthwwAUn3FrFesdT/pCx");
            sb.Append("JA1xGxlq0K0HYHbmsIi0BVxzRlwplz51GeTz5dAFAywwwYYDLjjh1gpTE/WapWxwEclD/HAhbzEf1PjvM6Jev/gdSg4MsMAEG46uzmK9txSmWn0VVbrOltdWnTHWe8ml");
            sb.Append("ZzBJRBxxZShg7kMcjhwZMMACE2w4gvYUjGh3Z4wRTzKZZCKe4QyI5hkYYJkqKHRD83WxjICkioYkkpfMlVOWFrqR6eEw13So5IrWqICKCdHAgs6XWBixZHLDIt0Ialwv");
            sb.Append("s/CZHrxM6/USBcOVvrB1R5ysK2pA7EKgvBBmgMUt/vObVdRGxK8M/Z4IWYb/yf2NSLXPmDUihRW2EUG+bK3Y2KyMHZOBsPzDqMg/jALHcZVvHKtNJn7juCpwHEdcSNQ8");
            sb.Append("j+tCEm4lY5NZuJKZajsWK9mKLqUpaild2lru34gDZsdS1vLFHkzUmSC2BxPeIPLRrHhRRzN6StRHM8OFK3o4NYwgHOQEiUl1UKL0ibntNeIQ9wtwPEcXDLDABFs/D5o+");
            sb.Append("/wBk7SKO9+DpXAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossYellow_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossYellow_Reset()
        {
            _CrossYellow = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossYellow_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossYellow = null;
        #endregion
        #region Image LeftBlue
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftBlue.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LeftBlue_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LeftBlue, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LeftBlue_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftBlue.png
        /// </remarks>
        public static System.Drawing.Image LeftBlue_Cached
        {
            get
            {
                if (_LeftBlue == null) _LeftBlue = LeftBlue;
                return _LeftBlue;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftBlue.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LeftBlue_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftBlue_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftBlue_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftBlue.png
        /// </remarks>
        public static System.Drawing.Image LeftBlue { get { return _ImageCreateFrom(_LeftBlue_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru LeftBlue.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftBlue_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftBlue_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftBlue.png
        /// </remarks>
        public static System.Drawing.Image LeftBlue_FromFile { get { return _ImageCreateFrom(_LeftBlue_string, "LeftBlue.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LeftBlue
        /// </summary>
        /// <returns></returns>
        private static string _LeftBlue_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2204);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAWiSURB");
            sb.Append("VFhHxVcJUJVlFOX/38Z7iMTywLQgZAc1hBaFF4oKxiqKgOMuaoULi6CAGygaTaU4BZlFGlYuuIwmgtnigtaM4loqmopLuObeqtjpft//A0+eC41IzDDDG2beOd+55957");
            sb.Append("rpnZ//QjiOJgQaE83PrwghivNNce1OkdoNTq0GoE6MUvEfA+C3sH6D19YOfuBfrcCgQE0Z+AKiz0Dnf1nt5w7P4KXHqFws6DCGh11U9OAUHoqjDXluns7OsYmGN3AzzD");
            sb.Append("+8F38Ah4hEVLCmh1VS1PQBC6KDTm63S2+joG4tjNAI/waHQdMhIB49MQmJwB97Ao2Lp5shK0IAFB8FFoNGu0tnZ32Jc7dguUgUchYMIk9Jo+G+Fvv4egjKlwfzUStq4e");
            sb.Append("IKItQUDwUqg1pVob29vsS599uR6YXkzAvafnIeKd9xG7qAQJS1dJBPpGwMbFnQhoHoOAIHgT8DJzaxsCdifgAF5bLjUDnkHA7xYi9qOlGLx8HUZt+BaJFVsRlD4VboxA");
            sb.Append("RzeI6v9OQGkmiqFUu01UY15HCTiKgEnqiekEPAeR8wox8OPPMWTFl0jcuAVvbN2FibsOYdKPJzkpt9BwWDu7MgWWNNeEakGhSFDqLPZb2LfjfczayTOiH7oOlYFnzkXk");
            sb.Append("/CIMLP4CQ0s3YHT5ViRtr0Jy1RGkHzqFzBMXMO3sNcw4dxMj12+GU2AQSMFFjyJgLSiV6SoLyxrL9h1g79MZzxl6wCuqP/yGj+aO7iMDxzHgVWUYvWk7xlXuRcreamQc");
            sb.Append("OYOsk5cwvfYGci//idnX7mDOzX8w9xZ4R4gq9QMJdBBVqgK1ZdtrVs84ol1nXzgH9YJ3v1j4jxiDwJTJ6JPz5r0vrtiGpMo9BHwUk4+cRXbNZf7a3F//Qt6Nu5hDoAy4");
            sb.Append("/jc4O4cIqJoQYD2s1nyqsbL+4yknZzzt64+OPfvAJyYO/iNfgyF1ihEw1Xgl1bh8C5K2VSGFS32aXnyx4cV51+vuATUmEJY/D4JSIiCYCWJP6slvqJXIna5o7/ciH5ed");
            sb.Append("BiTghVGvw5CWiZDcfOnF3FzrkVj2HTdXMjPXTzXIPH6e1zjn4u+YfbVRamNQ47/7FxWDtiEREMS1qjaWaEtSO3R6nszRg8wVA19qp+7jUhCclYOw/PmIKSxGQkkphq+t");
            sb.Append("wJjNlRi3Yx9SSW5W5+yaS5hRS3JfJrkf8mpjAoNKVjICBSYKWBsp4DMgXlIgNbNReqYAk56117bdSN59mLs86wRJ/8t1yWzNINGogHEfkAdEtbr0UR6Imv8BuOtZu8nm");
            sb.Append("S91TLZnvFJnv/C3MuvI3N9+DShA66y2Isgfu14pyF1jdpwvGwpAyBSE5+YgqWIi4xcswbPVGjPmqEuN37kfa/p8x5Vgtpp25KvnBqPWMyRiohU27wJSKNAfa1M+BLjQH");
            sb.Append("etIcGEBzQG5HMmfUgoWIX7Icw9dUYOzXOzHhhwNIO3CciJzjRGYSkVlXbzfMAEaEDbCHzYGmVNSCqEhUsUnoIE1CpwCahJEx8BuWSAOJ5gIRiV7wIRFZIRHZvAPjv5cV");
            sb.Append("OVqLqaevYOaF36g0t5FNw8klOKRZk7ApESVFK2kX2OkpVNAukNeuRIQmo6xI3OLlVJpyuTTUMfuOcY/EfbKM7w5rZxdGYOWjRvGD/8+2ocactqG8hokISzycCJ+U9R5h");
            sb.Append("RMgjNKKZYdlMYcuIzRsi8BjruIGaUR7gQYSiFy0pv2G0K+SRzc1KLx/02epGAi5uj5kHmmpjlIh4FGPbknmELa363TGvSCLA8gBliBZKRE2Y1GdCO8qELIxys8rbk4gE");
            sb.Append("sEzYlyKZm0cLZ0JTRaRUrLevY3HcKSCIr3HWfjwTslD6RFKxCRG6C7S6CjpI6C6g9qUg4tKb7gIplj/Bu6BpZRouI5ojXp14C7fOZWSqSDy9/CBdSq17G5rykK7jfwFx");
            sb.Append("3yji2LgOlgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LeftBlue_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LeftBlue_Reset()
        {
            _LeftBlue = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LeftBlue_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LeftBlue = null;
        #endregion
        #region Image LeftGray
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftGray.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LeftGray_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LeftGray, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LeftGray_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftGray.png
        /// </remarks>
        public static System.Drawing.Image LeftGray_Cached
        {
            get
            {
                if (_LeftGray == null) _LeftGray = LeftGray;
                return _LeftGray;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftGray.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LeftGray_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftGray_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftGray_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftGray.png
        /// </remarks>
        public static System.Drawing.Image LeftGray { get { return _ImageCreateFrom(_LeftGray_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru LeftGray.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftGray_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftGray_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftGray.png
        /// </remarks>
        public static System.Drawing.Image LeftGray_FromFile { get { return _ImageCreateFrom(_LeftGray_string, "LeftGray.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LeftGray
        /// </summary>
        /// <returns></returns>
        private static string _LeftGray_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1884);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAASzSURB");
            sb.Append("VFhHxVdZSJxXGFXjviBqIoiCGONSlYoUd9zALQmKT6270BeXaAgUwfVFwUR9iA/ihtribrDu0qLGBYz7Wo0b7qhxeehbH5KU0/tdcn/GcYwmVTMwzAzDzDn3fOc733eV");
            sb.Append("lL7RQ0VFJVJVVXX51uEZ8I9aWlp/3bt3D+wVt0aAAbtoamrOEbCNjQ2srKzAPt88AQb8AwP6gwH/a21tDTc3N/j5+YHeMwVWb0wBZWVlJwbcfffu3Y8CODg4GOHh4aBX");
            sb.Append("UoARmL52Agz4ew0NjXYjI6OPBOLq6soBIyIikJiYiCdPniAoKAgPHjygElwfAQZsz4B/NzQ0/EB/7uLicgY4LS0NeXl5ePbsGQIDA2FpaXk9BBjwd+rq6q8Y8PuLgJ8/");
            sb.Append("f47i4mJUVVVJBO7fvw9G+OsVYMB2DLjBwMDgPZ3G2dmZSyukTk9Px4sXL1BSUoKamhq0traio6ODEwgICAARYL//YgKqzNWBrHZ/shrzOpLUAjgpKQkZGRkcuLS0FLW1");
            sb.Append("tWhra0Nvby9GRkYwPT3Nv/P394eFhQUp8OtVTah+586dn7S1teeNjY15H1M7PXz4EJGRkRDA+fn5HLi+vp6ftr+/H6Ojo5idncXy8jI2Nzexvb2NlpYWuLu7kwLllxEw");
            sb.Append("YHH5i46OzraJiQns7Ozg4eGBx48fIyoqijuaTkzAZWVlaGhoQGdnJ16/fo2xsTHMz89jdXUVW1tb2N/fx9HREU5OTnB6eoqEhITPEjBVU1N7qaen97eZmRkcHBzg5eWF");
            sb.Append("kJAQREdHIzk5GZmZmRxY9sQCeGFhAWtra9jZ2cHBwQGOj485qOwzNTUVDOOsAtTDTJbf9PX1/zE3N4ejoyN8fHwQGhqK2NhYpKSkcOCCggIOXFdXh/b2dvT19XGp5+bm");
            sb.Append("sLKycubE8sDic05ODpi6nIAyM5YvM0Q/ayVuDicnJx6XYWFhiIuLw9OnT5GVlSWdWN5cMzMzePv2LTY2NrC3t4d3795JUl9EoKioCMxX5UoMvFVXVxempqawt7fnNSZz");
            sb.Append("UWTGx8eDpMrNzQX9oLKyEs3Nzejq6sLAwADGx8dBclOdyVxUZ0VyKyJB/8UIvDyjAOtpSQFfX19JASG9qLlQgKR/8+YNd/lVpRdk6ECiBFInfPLAK1kPeHt7K/QAuV60");
            sb.Append("myLzHR4efrYM2dnZ5wnI9OSFXRATE8PNSJ4oLCxEeXk5bz8qy+DgICYnJ7G4uHipH6iFz3WBglDgOcA8IuWAp6cnzwHRjoJIRUUFmpqa0NPTg+HhYUxNTWFpaelCIhTZ");
            sb.Append("VwkiwYmS8GfZJKQke/TokRRI8kS6u7sxNDQkKbK+vo7d3V1Qacgv1N5fQkAQOTMLaN6LsUuRTLLKEmlsbJRKMzExwTuGSkazg9qdEWi+LIov/J6mIcsOaRoSETEbZInI");
            sb.Append("eoTmA2WKGEZfMw3PEZLfB2gDIiI0KyiyZc1aXV3NCYhx/L/2AXkmYiNiY/oDlYampfCIIEI5IgjQDnGtBAQh2Z1QLKNERHQNlYdWsmvfCRUoIm3FtD9Q11D7klkFgRvZ");
            sb.Append("iuWJ0L2AAfF7ga2tLZ81NOg+reU3dy9QQITfjGijIiK3djNSQOTb3A0VEOG34/8AgWhxR1LbpSsAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LeftGray_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LeftGray_Reset()
        {
            _LeftGray = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LeftGray_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LeftGray = null;
        #endregion
        #region Image LeftGreen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftGreen.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LeftGreen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LeftGreen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LeftGreen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftGreen.png
        /// </remarks>
        public static System.Drawing.Image LeftGreen_Cached
        {
            get
            {
                if (_LeftGreen == null) _LeftGreen = LeftGreen;
                return _LeftGreen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftGreen.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LeftGreen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftGreen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftGreen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftGreen.png
        /// </remarks>
        public static System.Drawing.Image LeftGreen { get { return _ImageCreateFrom(_LeftGreen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru LeftGreen.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftGreen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftGreen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftGreen.png
        /// </remarks>
        public static System.Drawing.Image LeftGreen_FromFile { get { return _ImageCreateFrom(_LeftGreen_string, "LeftGreen.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LeftGreen
        /// </summary>
        /// <returns></returns>
        private static string _LeftGreen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2088);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAVNSURB");
            sb.Append("VFhHxVd5UNRlGGYPlituZZFTlENuOQQBOQRZClgudUHkRjStmYZQaZoaS1H8I4WKFIuZxIMC0dBQjFS86ABKcyazY7JjumzKbkulp/f7frvLupzDLMTMzrC7s7/n+Z73");
            sb.Append("eZ/3/YyM/qc/kdgoXyIVXZ12eAJWmZhJrtjKTWBiLsG0ESDgCAK+ZCc3hYe/DWb7WoPeTz0BAg4joC5buemgh5815sfKsVDhJBAwl1ybMgVEIqMQmZm409bB5C4DC14k");
            sb.Append("R1ymG9KKPRGb4aohMGBwAgQcJDMVd9jM1AA7IC7DDeklXsivDEDB+gDEKl3hPs+KSiA2HAEC9jc2ER+2nmFyhz08KMaBTkrApQT8aADWbA5F1XNRKH08GIvSXeHmYwUi");
            sb.Append("agACIiNfAm6ztpfdZg8VgF2FExPwg1vCsP75KDzVHI/aQ4koIQIxaS5w9bYC/W7yBOjEfvSAFis7AqaHBUUPB97QEIWn98XjmY5k7DqdisazaVoCLl6WkyIgJVcrqHYn");
            sb.Append("qca8jhyYasqkXlkVgLU1YdjYEI3NBxKw41gydvekorkvE60fLkXH57lgpKJTXeDiyQm8PFETysQSUa6pheSynSPrY6GdmKuVGuCtBPxCNLYcTMDO1xXYQ6fdN5CFto+W");
            sb.Append("4dgXeXjj+5U4c7MI534rRkP3AwiJc2QE9oxHwJbissrMUnp9prMZ5gbaIjTeEQnZ7sgo9yZHB2ItAVerges6FXjxfDr2v5+N9mvL0fnVCnTfKMDZX4tx8VYp3rlTjv5/");
            sb.Append("KzCA1bwjpDLRqAScpcaiOgsr6U25mwW859shPHEWEpe6I3OVNwo3BGLdtnAtMD/xuTTsfy8L7R8T8Ncr8OaPhXTaErz1dxneHVyFfgjAmlfFplAQxr0EWA+TLHstbY3/");
            sb.Append("cvK4D/PC7LFgySwkLZ+NrNU+KNw4BCzUWIHGHkHqQ0zqL0nqH4QT994i4LvDgTUEKncshERNQETGSqCePEWtxM3ht2AGIikul+R6IHuND4qqg7CuNpzXmAMfJXOdScVe");
            sb.Append("bq5lOHo9Dye/E2p84c97pdY9te7/TzbFQSwlBQj8CNUYcjdzeAYLNY7PEpIr7xF/VGwKQeXOSDzRFIvatkQ823U/XrqgxIFL2TjM5NbUmczVy+SmU48Gqvt5bWsSI1DH");
            sb.Append("TKhVwEqtgK9GAZWOAlRzrQK8vdLQ3E8uv6p2OUnf8wuTvnRCJJgCZPARPCATt43rgV067cbNp3a9xny/k/n+KUMfmW80NR7eHqH1wEitKHSBtX4XkBkrqAuYGckT1btj");
            sb.Append("UNOyGPXHFVSWdBy8nI0jn6pw4pt8nP55bD+wFh7WBSMw4Tlgrs4BzyDySALlQM5QOz5ERB4jIltfWcz90dSrRMsHOXjtMxW6vtUhcrscfeoMYKooS73HzAF9LiwJy1gS");
            sb.Append("2vMktOFJyMyaUeaFAsoFTqSRiLzKiKSg6aKSFMnRKnLqp0Kc/6MEbxOR7huFiEh2mlAS6hNRzwLJ0Cyg6cfmvZIRIVl1Fak/kSKUhnXMJyoeUDUtCXx2uMzls6B1vCge");
            sb.Append("9Xs2DSk7WqhztGOYzYaMMopolpTq0tRQaeqPp/CIZmlZVB2oO4wmP461zHT2ATYdgxc5IJ4RYbNCHdnMI8ys29uTtARcJzmOx1JkaCNiO6DGI0REMztYjrBUZQsJ2yEM");
            sb.Append("sxHpUdLfCblZswVFGBG2E8akEwG2khlyJ9SXRncrZut4SJycj3G2P7CdkC+l5hIDeGAcG/N7gbmkiy4kg3OofRmRSIXz1N8LhimiuRlRjswJsCEFpulmNAIRFSlyhV3R");
            sb.Append("pvVuOAIRfjv+D41d5oacl1rJAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LeftGreen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LeftGreen_Reset()
        {
            _LeftGreen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LeftGreen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LeftGreen = null;
        #endregion
        #region Image LeftRed
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftRed.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LeftRed_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LeftRed, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LeftRed_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftRed.png
        /// </remarks>
        public static System.Drawing.Image LeftRed_Cached
        {
            get
            {
                if (_LeftRed == null) _LeftRed = LeftRed;
                return _LeftRed;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftRed.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LeftRed_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftRed.png
        /// </remarks>
        public static System.Drawing.Image LeftRed { get { return _ImageCreateFrom(_LeftRed_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru LeftRed.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftRed.png
        /// </remarks>
        public static System.Drawing.Image LeftRed_FromFile { get { return _ImageCreateFrom(_LeftRed_string, "LeftRed.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LeftRed
        /// </summary>
        /// <returns></returns>
        private static string _LeftRed_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1832);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAASNSURB");
            sb.Append("VFhHxZdpbJRlFIXPzJQuIEsBKVopENkLRayibKWijEqLUJZWcYEOiz+NopL4h8T9j5IooiQkLtEquAQVxBh39I+iVBMRl4hL3DCK+8Li8dzvm/fr2+l0SWlrk0mmmZnv");
            sb.Append("PO+95y4v8D/9xYFlOYjt63F5CdcWIPF+EfLYGwn2GICEp0p4bxHyWYoBHI/+1P/dDyDhcgntkvCxCRKdhSImcXIAoAjs77YIxIApBYjvGIK8oyY2U8ILUMLlGMWLMMwB");
            sb.Append("7OlyAAmX5SO+/cRIeIgES7gCo3k1JvJaveYLYBz6KQXxrgOQcGke4k8ORt4Re/gMhML1Er5GojfidN6FabwBk1ktgLH6jkCPH0DC4yW8bRByD9tDQ+FhwYlN+CaU824J");
            sb.Append("P4jZfBxzAoAqnMIx+q5+13kACU/QAxoGStgeNj2L8EYJPyTh7ZjLlzCPr6IqAhiNvp0CyJGrk8rd88pxkEcTtpxaqNfqxDfrxBsxnQ+jks9I+BUJv4UF/ACL+Rnq9Nk0");
            sb.Append("zlMERoUA93fUhLkJxOr6INE4NKjjsJzM1U74FgnfI+FHJPwsksFp92AhP8QSfo6L+R0u5SFcwV+xnC/gQlZgqAFsbg+gUO1ybV/kHChGASehkLP1wxoM50qMkaMn0Rfe");
            sb.Append("IeHXUc13UcP9WMovcQkP4jL+ItG/UM8jWMl/sZrEmqAichFrFaC4F2Ib+iHnUAn68DQM5BycxMUSXiXh6yR8K85oduLXdOJ3dOKPJPyVhH/A5TrtCv6NFI9hlURDYfda");
            sb.Append("r6qQRnMAq2GF5YFC9PpzJE5gOQbxPAkvxQiuwVhe7wmHOU4qx02h/kKh/j46cYpHswg7gDtwdgQQk7EqVZMvqpQCc5yJwUG7rMNIXinhdSjjbekTm/DTMtfLkbmW8ICE");
            sb.Append("v03n+I+MUPun9t9vQQWV3s2Q+FPKMUvQm5PTOV6Y7lxXoZTrMYV34ixuwSxuUx3vwgXcjfncqzxbuF2ezVwW7vDUTaFu7f1WnGsAG8yErUag1ouAy3lTeVXxbeV8X9rl");
            sb.Append("Fvqf02brCEQUAb8MzAO56mrteWCTV26h+ULXO/P9JvP9E5kvezRux9SWJvRggiro36IKRnC1qsDMaJ64FzPYgHO4U2bcrfJrFMgnqOXXWMafVPNt+cFKuEUVZGkKzfpA");
            sb.Append("mTxSqT6wyCtHB/KoQMwfb8of72ERPxXINx7IYa8HmC/qdZC2+kAmi3XCVFMnHBB0QjNrSi3Y+oKB3KeIPBaAnM83BNIoEBeRH9UXfldqDOSg3s9VlXWkE2aCpGdBIpoF");
            sb.Append("buwaiIXVj8hzArHUWMV8rIiYRxpUxjY7Tg1nwdb2WnGrn9s0VO9o8MewzYZUulP6IDsFYi3aDLtOkN4w6vw4dmT+PmDTcaamo4HYrHAt25n1CdW+A+jsOG4rItFGZDug");
            sb.Append("84gPYtPSuqpbSLpkI8okytwJDaTGi4jthNXaB2x76tKdMAtItBXbOl4RgAwP9gfbCS1dWsuP3wPtudjuBRIK7gV2ITGQJIq7/16QCeZuRrZRTRTIuJ66GWUBqVVEdDfM");
            sb.Append("79m7YRaQ4Hb8H8skKSLHiO7aAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LeftRed_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LeftRed_Reset()
        {
            _LeftRed = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LeftRed_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LeftRed = null;
        #endregion
        #region Image LeftYellow
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftYellow.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LeftYellow_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LeftYellow, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LeftYellow_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftYellow.png
        /// </remarks>
        public static System.Drawing.Image LeftYellow_Cached
        {
            get
            {
                if (_LeftYellow == null) _LeftYellow = LeftYellow;
                return _LeftYellow;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku LeftYellow.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LeftYellow_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftYellow.png
        /// </remarks>
        public static System.Drawing.Image LeftYellow { get { return _ImageCreateFrom(_LeftYellow_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru LeftYellow.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LeftYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LeftYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\LeftYellow.png
        /// </remarks>
        public static System.Drawing.Image LeftYellow_FromFile { get { return _ImageCreateFrom(_LeftYellow_string, "LeftYellow.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LeftYellow
        /// </summary>
        /// <returns></returns>
        private static string _LeftYellow_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2004);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAUOSURB");
            sb.Append("VFhHxZd5TNNnGMdpC+UaN1KUSyKH3GqnG3dFKRsUoSAF3RhQDv80ikriPyTe/6iJ4pWQbBpFQbeggixm3vqPouASEY+IR7wwiudUDr97n/e3X1tugsCaNGnT9Pf9vM/z");
            sb.Append("fY7XzOx/ekmlZovNzSUtEy7PhHXW1rK/FQpL2NjIMGEATHgOE25SKKwQEuKIoCAHsO/jD8CElUyogQn3BAc7IDZWAbV6CgdgEWgdtwhIJGYzra2ldW5ult0kFhOjQFqa");
            sb.Append("N/Ly/LBggZcI0DjmAEw43MpKWjtpkijsxgS9kZ/vj2XLQrFiRShSU70wfbo9S4F07ACYcIilpfR3V1fLLnp4dLQgXFDgj+XLQ7FmzSxs2xaJ1asjoNF4ITDQHgz06wGY");
            sb.Append("cBATrnFxkXfSQwVhL35iEl67Vont2yOxd288Dh9O4AApKZ4ICLAH+9/oAZhwMHtAlbOzvJMeFhXVX7iiIhL79sWjtjYRp04l4+zZFAOAv7/dqADMmavVLHd/shzzPJIw");
            sb.Append("5ZRCXVoainXrlKioiML+/SocO5aIM2eScflyGm7cyMS9e9nst0gkJ3vCz48D/DpSE8plMkm2ra2s2d2d6lgoJ3K1KLx+vRI7dkThwAEVjh9X89M2Nqbj5s2FuH8/B8+e");
            sb.Append("/YSOjl/w9m0eTp78EXFx7gSwZzgAJ9YuS+3szNs8PKwRFuaE+Hh3aLU+KCwMYI4Og6lwXZ0a589rcO2aFq2tWXj4cBHa23/Gmzd5+PixAF1dhfjypRhACa8IuVwyKICH");
            sb.Append("hYVkq729eYe3ty1mzHBGQsJkZGb6oKgoACtXhmHDhm97nfjcuRRcvZqOW7ey8OjRIrx4kctOm49Pn/To6SliooKw+C4vnwWm0RuAapiF5TcnJ4t/fH2/gVLpgvnzJyMr");
            sb.Append("aypKSgKxapVRWMixmuXYGOoHD3Lw/Ll4Yj26u/sLiwCbN39vAJAwY6lYTf7FSombY/ZsV94us7N9sWRJIMrKwrFxo3BiEj56NBGnT4vmWoi2thw8fSrk+MOH3qE2PbXp");
            sb.Append("58rKOLD07jFj4n+wHMPb2wYREUKO09OFzrV0aQjKy2diy5bvUFkZi5qaBDQ0/IALF1LR1KTl4RbzTOaicAunNoZ6sM/V1fMIYCuZcNAI6HTGCIg5N5ZXCq5cSUdLi+By");
            sb.Append("Cv3r14LZRgJhiIBpGZAH5HJpzXAe2LnTWG6C+QTXi+Z79y4fnz+L5hs4Gps2zelvQhMYXgUODn2rYCqKiwO4GckTu3ZFo6pqLurr1SwtGjQ3a3Hnjg6PHy/Gq1dD+4FK");
            sb.Append("uF8VDNAUevWB8HAnqFTuyMgwlqMIcvDgXO6PS5dScf16Bu7e1eHJEyNIZ6exB5AvCgoChuwDfVmoE+qNndCRd0Iyq17vz/sCgezeHY1DhwgkCRcvprKIZBgi8vJlLt6/");
            sb.Append("zweBtLfnIjFxyog6YV+Q/2aBzDALxLFLIBRW04icOJHEU0MVc/u2jnukqkrFZ8e0aXwWVA/Xigf9naYh6x1VpmOYZoNeL3RKU5D6+iTeosmwZWVhpsNo9ONYJDPdB2g6");
            sb.Append("xsS48SFFs0Js2aJZjxyZZwAY7TgeKiKGjYh2QNEjpiDUSamrigvJmGxEfYn67oQEotUaI0I7oUbjyVeyMd0JBwAxbMW0jsfFEYgP3x9oJ6R0sbX86z0wnIvpXsCE+L2A");
            sb.Append("LiQEolZ7jP+9oC+YeDOijSo01JFFYIJuRgOA6FhE2N3QamLvhgOA8Nvxv4hwGAOb5pUGAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LeftYellow_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LeftYellow_Reset()
        {
            _LeftYellow = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LeftYellow_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LeftYellow = null;
        #endregion
        #region Image RightBlue
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightBlue.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu RightBlue_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property RightBlue, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property RightBlue_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightBlue.png
        /// </remarks>
        public static System.Drawing.Image RightBlue_Cached
        {
            get
            {
                if (_RightBlue == null) _RightBlue = RightBlue;
                return _RightBlue;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightBlue.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image RightBlue_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightBlue_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightBlue_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightBlue.png
        /// </remarks>
        public static System.Drawing.Image RightBlue { get { return _ImageCreateFrom(_RightBlue_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru RightBlue.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightBlue_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightBlue_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightBlue.png
        /// </remarks>
        public static System.Drawing.Image RightBlue_FromFile { get { return _ImageCreateFrom(_RightBlue_string, "RightBlue.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru RightBlue
        /// </summary>
        /// <returns></returns>
        private static string _RightBlue_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2160);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAWCSURB");
            sb.Append("VFhHxZd5UNV1FMXfyioa8BDT1AB5PEANoTIf5MZiyuKCgIOAspi7gCgCqYhoNpXolGYUZVqp4DKaKGabitaMPhUz19zNLVNcWhU6ne/v90Cc1EgBmXGGPxzu53fuuefe");
            sb.Append("r1qp1hxUKhWVCmC/4nH8aKxtYOPkDI2V9fcKpSq6yRlYGDq9J5wM3rBtKYHsVapUzzcZCBU4rPPwhFvvELTr9iJBvGDr5FxNkDIq4tfoIAQwCQU8+kbAJ3YYDP36EyQA");
            sb.Append("Og8v2OhaVqmtrEsVSmWXRgPhl5oc3Q3Q9w2H/4RJMI6diC5Dh8NDgLxAEMLZODpVqS2t1hKkc4OD8A+bHDt4QP9SGLpPykG/199C76kzYRwnQBIJEkEQfwhIa0fdbbWl");
            sb.Append("5WqCeDcYCP+gycFND32fUAkgZulKRBYuQegbbyNwar4ZRCgSgbZdCUJYawfHW2oLyxKFQun5yCAqCwK4usNdAGTkIGnjFiSu/wqxy9ci8r2lCH1zAQKn1QGhV9p2NRJE");
            sb.Append("Dyt7CWQZFfF6aBAqsNjepQPcQ/pJxSbuP4HxOw9g1JadSNrwDYau+AyD3/8EYXMFyCwYx2fIraFnJBC2hh4R47tJoVKFEETzv2D4BYXt/Xtg+LrNmHb+Bl45W4kpxy8i");
            sb.Append("48ApTDAdwuhtJiRTlbiS9Rhc9CnCChYicPpsGSQuEYZQMTVifEWOtILGxrZCqVbHEMKiXiAqrUWhcWw6Zt8EZt34GzMrb2PG5T8w9dx1ZJ34GZMOnUHqnsMYU74HyZu2");
            sb.Append("IW5lKaLMIEEEEZPjm5AMz/CBeDqgB1p6d4Jd6zbQ2tqdVGo0GYSwfyCISqst7JWdKwHU/JvF3/OvV2PGL39KqmSfvIzJh84S5AhGl+9GctnWuxQJyn0V/qmT4TcsBV79");
            sb.Append("I+HSvTdadfJBi6fawcKueSVrzCNEm3uCKDXawr5zCu4CqAuTf62qjiKX2JrTSBWt2WqiYemRYnqkiB5hawRIQFom/Ia/DO8BUXDtGYQnffzwRHsXWLaw/53t/uhfWcJt");
            sb.Append("WDhwYdF9AWpbc/U2ci/9Jnvk2AVM/OEkJtSYtfRrmnWdbFaCBM+Yg4D0KXg2aSQ6DoqRYr6173NwcO0gRhjMni8Z8z2piFJBgHlDlhQ/EKBGEVkNtuWcaIvsjzS2Zcz2");
            sb.Append("vUjZXI6ENWWIWVKCAQuKIFTtlZWLbmNS4cNkNYQOgDC7c8dn0Jyt0TazAyHWCID/VEAAzKxpxU/XkHVctIJTsusgRm3dJY+raIVZAbkVVCBxJLwHRdcqYH8vBVT0QEje");
            sb.Append("a/f3AM2Yd+UvTLtwE9mnZDOm7b7bjGIqwgveeTgPiCkI4CjVNV7dkZT6fuYqMo+eQ3rFjxi7owIpn5cjftUGRH24DOHzFiE4lz1PpfmGjbjHFLR48BSIHBCBUjuCzIK8");
            sb.Append("q7cwvbbweaTvO4Zx3+3DiC92IGF1GaIXL0f4/EUIotnE+PkmpDAHBjEHejIHOss50KyeOSCS0K1XsGSqvCssfPFX5Jy+gswj5i/+tgIjNm83F16BiPnv3ikcnwRDGM1l");
            sb.Append("NCehcytoRRKq1En1TkICFNu7uEnZHvXBMrnHe49SajpbknojpZa/WIyXlHwsLG1HrmmdnrtAJ+8CnnIPtQu4DeVlJGZXpFwKI1fuMQuzx0HssSS1+GIeKqKwWMvSNrS0");
            sb.Append("euRtyHuA69gMMOTjVZIScmE5Yn3jk+WlwwtJOkwa8h4QF5EDd7u4B4QCYXPlSJXNxcLssdh24jRrlItIvgl5kvUJg5H9vVN4INrRXOJiZo8b7yYUV7F0lPImFOMo1mp7");
            sb.Append("Y3fpPLdxaoqrWLwLKK9bYAizWhSWHijVBGuid4H0MjLAybOjfNE8hpeReAmBX/x43obS61iliq3X/dYI/+kfQUssStvG8FMAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property RightBlue_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void RightBlue_Reset()
        {
            _RightBlue = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití RightBlue_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _RightBlue = null;
        #endregion
        #region Image RightGray
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightGray.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu RightGray_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property RightGray, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property RightGray_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightGray.png
        /// </remarks>
        public static System.Drawing.Image RightGray_Cached
        {
            get
            {
                if (_RightGray == null) _RightGray = RightGray;
                return _RightGray;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightGray.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image RightGray_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightGray_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightGray_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightGray.png
        /// </remarks>
        public static System.Drawing.Image RightGray { get { return _ImageCreateFrom(_RightGray_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru RightGray.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightGray_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightGray_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightGray.png
        /// </remarks>
        public static System.Drawing.Image RightGray_FromFile { get { return _ImageCreateFrom(_RightGray_string, "RightGray.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru RightGray
        /// </summary>
        /// <returns></returns>
        private static string _RightGray_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1848);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAASYSURB");
            sb.Append("VFhHxZdXSGZnEIbtXcQKoiB2o7IiwY6oYBfFq8Qu5MYuQhCsNwp2WC9E/UVNsBuJXRLsgt3ftnaxY/di73KRbHjzzcFzUNc1upYV5Fh+zjzfOzPvzCctIyOzLiEh8RHA");
            sb.Append("Cnu+/ZeioiK0tbXBnh+kpKR+eHMCBQUFmJqawtzcnANhvy8yEPs3A2En3zQzM4OHhwccHR1BPzOQfxnIHwzk+1cHYQBiUsDX1xchISHckwfR0tL6xEB6JSUlbV8NhAUQ");
            sb.Append("m5iYwMfHBwkJCYiLi0NoaCgH4uDgwKVHU1Pzk7y8fCcDeffiIOzFYmNjY3h7eyMlJQV5eXlIS0u7BWJvbw+C1NDQ+Id9/ncGYvViIARgZGQkANTU1KCsrAz5+fkPgfwt");
            sb.Append("Jyf3GwP57tkg7EUcgJeXF6dAV1cX2tvbUVdXh/LychQUFCA9PV1QhFJlZ2cHUk1dXZ1AmhiI5VeDMAV+MTQ0hKenJxdMLBZjfHwc/f396OjoQH19PSoqKrj/ZWRkID4+");
            sb.Append("nqsRAuFTw2qE2vdP1jXeDETmSTDsBCInJye0tbVhf38fu7u7WF9fx8LCAiYnJzE4OMip0tjYyIEUFhYKIGFhYfDz8+O6hnxER0cHSkpKS9LS0j8yCLlHgRBAbGwsrq6u");
            sb.Append("cHl5ifPzcxwfH2Nvbw+bm5tYWlrC1NQUhoaG0N3djaamJlRWVgog1Dnh4eEICAiAs7MzLC0toaurC2Vl5X1m8z8zCPUHQWRlZUWpqakcwM3vi4sLnJyc4ODgAFtbW1he");
            sb.Append("XhZA7iqSmZmJxMREREREIDAwEK6urrC2toa+vj5UVVU/shjvGYTevSCMUpSTk/MZAA9zU5GNjQ0sLi5yqRkYGEBnZycaGhq41BQVFYFAkpKSEBUVhaCgILi5ucHGxgYG");
            sb.Append("BgZQU1P7i6n962dewvIlKi0t/SIAn5qzszMcHR1hZ2cHa2trmJ+fv7dYqUaysrKQnJyM6OhoBAcHczZva2sLKnbmJWCFP8gK1p0pIinBAN5XV1c/CMCrQWmh+qBipfqg");
            sb.Append("tExPT2N4eBg9PT1obW0FvYsOlJubC0ptTEwMZ/FUrFQjVlZW0NPTg4qKChhEuwSl4P8UIIC7qaAumZiY4FJxs11JAT4VvALu7u6CAsw7bitAANnZ2V9UgDrj9PT0wWKk");
            sb.Append("rvjqGqAuoFa62wUU+GbeV1ZWMDs7i5GREU5uakeRSITi4mIu51R8kZGRT+8C8gFyNh7gbuDV1VXMzc1hbGwMfX19aGlpQVVVlRCYbz/yARcXF8EHWI4f5wMEQO1CRUVS");
            sb.Append("Hx4eYnt7G/yJR0dH0dvbKwQuKSnhTswbkL+/P8hJ7zjhT09xwlZqD/J2kpQqe2ZmRpC6ubn51okpMFkw7Qs0C673hWfNAjE/jKh3yeXuyzEfmNqJAvPTkPX0s6ehMI4J");
            sb.Append("oLa29lZxUY7J6ykwbUjXi8nL7QP8RkT7AAHwTsYHphzTtLuW+uU3In4npJWMZOarmg9MW/Kr7oS0FZOsBEDFRe3EV/WbbMV0LyB5aWCQV1tYWHD3Avb3t7kX8DcjCkwb");
            sb.Append("zbe4GX3buyHdjtlYDHvU/vYKH/oPDsV1opHzZ3EAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property RightGray_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void RightGray_Reset()
        {
            _RightGray = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití RightGray_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _RightGray = null;
        #endregion
        #region Image RightGreen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightGreen.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu RightGreen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property RightGreen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property RightGreen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightGreen.png
        /// </remarks>
        public static System.Drawing.Image RightGreen_Cached
        {
            get
            {
                if (_RightGreen == null) _RightGreen = RightGreen;
                return _RightGreen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightGreen.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image RightGreen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightGreen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightGreen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightGreen.png
        /// </remarks>
        public static System.Drawing.Image RightGreen { get { return _ImageCreateFrom(_RightGreen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru RightGreen.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightGreen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightGreen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightGreen.png
        /// </remarks>
        public static System.Drawing.Image RightGreen_FromFile { get { return _ImageCreateFrom(_RightGreen_string, "RightGreen.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru RightGreen
        /// </summary>
        /// <returns></returns>
        private static string _RightGreen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2056);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAU1SURB");
            sb.Append("VFhHxZd5UNR1GMb3kuUIlkNBYbkUF+QUUFSQQ5S1uFFE4pJDtGumMVCapsZSCP8otCKVciYxpTwwJBQ1D7wqcUuryeyY7JjuKbotj57e9/v7Le4WKiogMw7/4D6ffZ/n");
            sb.Append("Pb5qtUZ5WqFQ9CigeI9+D/2P1l4NFw8ttHbqd5UqRd6QE5Aw/Mbp4B/iDFcPWwY5SSAxQwZCFTjDAJONnhgf7wH/YB1VxPYSgXQSSPSggxCAiQHiM72RNi8ACVk+iJjq");
            sb.Append("AT8GcddetLFTdSiVishBA9HaqUy+QU6Iz/BGUXUoCh4IRXrpWBnEXdjjPIJAbFVtBBI+4CD0wSafQCdMTfdG2UMRqHp6ChYui5JAyggk0wfhce5gSN1w7YVhWlUrgYQM");
            sb.Append("GAh9oMnb4IS4ND1KCaB+azIebU5E9TNTcNfy6N6KsEUMwrA6N5vz9P+2KJSKcTcNwgD6sY69AGu70rB6fyqeaEvBYxsSsbixD5BYAiFoJwmkhSoSfMMg9AEv6AMcEZuq");
            sb.Append("F2Jtn87F5vdno7k7C2sOpuLJ9hQs25iEJY2xuLs2GoVVkjWcmXACYWsoI9S+qt3UNUYC0VwXDAE0RSaOROPeO3Do13k40FOCPd8Wov2zfGz5IBcbTNlooqo0vGrE8k0E");
            sb.Append("8iyB1EkgGZwR6hrRviE6uI60ha2D+pRKrZxLEDb9AtHYKJsKFoXChAU48U8l3rxQgaPnytD1yzzs/b4IHV/ciW1n5uDFt3Pw3OF0rOyQQGpkkKLqMGRWGJCU44so+iJj");
            sb.Append("wlwwwssOdo6aszTmqwjC5aogmmHKpsqlUQLA/O8EKnH80ny8/lc5VaUUr/1QjI4vCeRDAnmLKnLockUY5J7HJ6B4cRiy5huQPNsXE5JHwTDeFR4+DnBw0vSQxkqC8OoT");
            sb.Append("RE0AixomWwFYgVycj2PnykVF9nxXhPbP87FVtmbtwTTKiFFkpBdkSRiyFwRi+hw/TJwxCkHRbvD0vw2OLsP+JLvX/2+WqDTKpkfWJfQJ0AsiW3PkjzKRkd3fFGLH2XwK");
            sb.Append("ay7Wc1gPUFh3yGHlitRPQElNOHIWBmLGXH9MojEfPHE4OOzUwqDZs48Cm0QVUSoIYGX95ulXBTCDHOdqkC1dFFZzPlrJlo0nc/D8kQw81Xk76rck4+F18VjUMAmVSyOR");
            sb.Append("f3+ImKyJ2T4iIwERLmSNPWcEBLFdQUG5ZgUYQIhTOA/+LFvBXXI6F80nsqld2QqLClAmeiuQZ10Bmh3WFeAM3Lci5ooV6OYw/k1h/O2/YcyxDuNqOYzXmwHuAm4lyy6w");
            sb.Append("bEn2ff9PJdj1VQG2f5yHTae43OlYtdOI2pZpqFkTJzwvZuFK7gI/6y7QXaMLeA5klBl6Abo5cOcrYBbu/LoAr3ySh5Z3ZmHdMcnnupem4UESvpeF5fZLmkVzIIk8Dpfm");
            sb.Append("gH1/5wBPwpgUTwpVMd4g4cO/l2Lfj8UW35iEj7LwTNS9TMJrJeEiEs4sl8IlTUJnuF2ehOX9noQEsFk/xlHM9tqWJDFwWj+iUotkU6l3kbDFN2a7MkjYck1Lu0B9w7vA");
            sb.Append("ZF5GJTVhIlg8clftnIlaWZg9lr6xQcx+81rmbUg9fdPb0ORN65i3IQOs2DZdhIs95hErhGnWJ4pTTT5MBvIeEBeRfJBw7/K2M892IUweR5DHvnSaDcpFREenOMni0vXi");
            sb.Append("JuRUC+EcKVyDfhPyVcxHBd+EvN95rUYmyOf5kFzF8rtgktFLCI+WHiiXCGyI3gX0MvIN0mF0KAlTH9+Kl5H0JLO/RW9Dfh3TWizo1/02CH/0Lwfq6O0bjfbDAAAAAElF");
            sb.Append("TkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property RightGreen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void RightGreen_Reset()
        {
            _RightGreen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití RightGreen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _RightGreen = null;
        #endregion
        #region Image RightRed
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightRed.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu RightRed_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property RightRed, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property RightRed_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightRed.png
        /// </remarks>
        public static System.Drawing.Image RightRed_Cached
        {
            get
            {
                if (_RightRed == null) _RightRed = RightRed;
                return _RightRed;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightRed.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image RightRed_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightRed.png
        /// </remarks>
        public static System.Drawing.Image RightRed { get { return _ImageCreateFrom(_RightRed_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru RightRed.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightRed.png
        /// </remarks>
        public static System.Drawing.Image RightRed_FromFile { get { return _ImageCreateFrom(_RightRed_string, "RightRed.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru RightRed
        /// </summary>
        /// <returns></returns>
        private static string _RightRed_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1804);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAR3SURB");
            sb.Append("VFhHxZdnbNVlGMXP7S0tBRkVLGgRIUIZhSJWUUGgolSFMlqkVRzQQvGjUVASv5C4P0HibkLiiFbBEUQQY1ScX/QqqAFxRBxxYbRuFKjHc/6D3pbRUtrS5KY3t73/5/c+");
            sb.Append("5zzjTWYisQNAA4GP9Lvrf3ogyQHIZg6SH2YAlV1OoMAchT4sRF+BdDfIVoFM6DIQZWCnAUpxCidjAEfrvUAaBbJZIMWdDiKAlAFm41QuxDDOwWCeH4HkIXt/DjI2JoDx");
            sb.Append("nQaiAKmR6M1ZAliOMbxBr0UYHoHkBfKcJJDuyFgvkKIOB9GDUyMEUCaAmzGOd+M83oIzA5BqgcxWRiYhj4bsj+x92ch4RiCFHQaiB6YK9PCZGBQAPIVpfARTeY9AbkXx");
            sb.Append("gYxYIoMYth+y9up76wQy6phBDDAcvQ4AvIaZfAUzuB7T+ahA7j0EyESBGDoCqRfI6HaDCOChYQKYoQw42Beo4nbM4zuYwy0C2SCQx1Civ03kbcrIskgae8YglkYeUflm");
            sb.Append("vKiqKRVI5lHBCKBuKgbyJVzK37GQDbiGP+BKfonL+TEuYwpz6aw8j1I+LpD7BHJ7GoirxuVbKLMOVB/pieS2JBJVgshqE0gWEnXX61TEUv6HWu7DYu5BNX8TzG5cxa9x");
            sb.Append("BXdiPt9HOd9AGTe2AFmOsVyMApbjNPogY5HLfOSwFzJ3qc0vE0TuEUG6CWClXG+AplctG7GE/6BGWVnEn3A1vxHIJwJ5Txl5vUVG7sBZvFEgSwQyTyDTcDLPwIkcjJ7s");
            sb.Append("jcwGxVgtiPxDghhgFc5tARDD1HK/QPYIxBn5URn5Kk2aLQLZoIzYI5bGIDcJZClGcD6G8CKBFKMfh+IE5qLb35L74YN6idJUtwZTDgMQgsTS/CVp7JHv5ZFdAtkuj9is");
            sb.Append("r8qsz0VmNcidAlmBIl4rkCoMDdr82ehPm12VQ/Wel2XYEmUkIcsmVq/FhUcEiKVxNkJZmvxhWbbKH29iFjfjEq5TH1mDyVyFc7gS43kdCoPOOldmtUfGySOD0cMeoSCe");
            sb.Append("NUCrGTBAKEU1f42kcJXsUAbelSdCKcJyjaWIM1DZWgbsgbsw4bAZsBn/1an/OMiM5c3MeH97PWAAl1LzKmiu+y/S/Vss4Geo5LYg3WXcJPPV4wI+gEmB5jZfbVAFQ5pV");
            sb.Append("QZ/WqsB9oFpfjAFsuL3qBTacA3+nwJ8r8Aeo4NuRzk+kBY7Lr0LlVyKNi462D7gTTpdLd6vWHfhPpfpnvW86cQXfCgJfzCcV+MHoxA5cE5kr7IR90zthTZs7oQDWnq7y");
            sb.Append("cG+vl4nccD7ViUNnl/EFBU4/seVy4PQxHc6CZLtnQSoeRiv0cHc5t9xNLQKHJy4IFpX0sayaPuZpGIxjT0MDPK2eEJsrbrHu9eGqFk6/Dt0HvBHFC4lrN65jn9iB3UCs");
            sb.Append("sVezTtmIvBOGK9mgYCeMA5enBe7UndBbsdPqndA7oMfqlK7cipvuBflB4OiC0qjPu+Ze4JvRSOk7Jqrj43EzCq5kOvHxuRv6dqyxuKBN+1sn/NP/ercriI56AAIAAAAA");
            sb.Append("SUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property RightRed_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void RightRed_Reset()
        {
            _RightRed = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití RightRed_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _RightRed = null;
        #endregion
        #region Image RightYellow
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightYellow.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu RightYellow_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property RightYellow, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property RightYellow_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightYellow.png
        /// </remarks>
        public static System.Drawing.Image RightYellow_Cached
        {
            get
            {
                if (_RightYellow == null) _RightYellow = RightYellow;
                return _RightYellow;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku RightYellow.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image RightYellow_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightYellow.png
        /// </remarks>
        public static System.Drawing.Image RightYellow { get { return _ImageCreateFrom(_RightYellow_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru RightYellow.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití RightYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property RightYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\DJs\Neuronic\source\arrow\RightYellow.png
        /// </remarks>
        public static System.Drawing.Image RightYellow_FromFile { get { return _ImageCreateFrom(_RightYellow_string, "RightYellow.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru RightYellow
        /// </summary>
        /// <returns></returns>
        private static string _RightYellow_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1972);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAfCAYAAACGVs+MAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAuIgAALiIBquLdkgAAAAh0RVh0Q29tbWVudAD2zJa/AAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAT2SURB");
            sb.Append("VFhHxZdXTJRpFIanAENZQBYElCaRDgMq6q4gRZRxlyIMZVAUYYbipVFQEm9I7FeY2ElIXI2ioLtBBdmYVaw3OgruRsQSscQexboqxXfP+X+GYXQVRMBJJpNMO8933veU");
            sb.Append("T25mJm2RSCTtgOQfeh35h7W1HC4uClhZyf+WySSaESegwAgMtEdw8CgCsWSQJgKZOmIglIFWBlCpxiIqygVBQfYM0k0gDQQSPuwgBKBngDlzPJCb64OUFE9Mny6CODsr");
            sb.Append("uqysZHVSqWTisIFQAH1AgB2Skz1QUhKCpUtDkJfn2wPiLMgzerSiy9JSVksgoUMOQn+s9/e3Q1KSB1asCMPGjdOwcuUkAUSr9aXMeCIy0hkM6eSk6FQoZL8TSPCQgdAf");
            sb.Append("6v387JCY6C4A7N8fh507Y7Bp0zSsWhXemxGWiEEY1tHRooN+V0Mggd8MwgC+vra9ACdOJOLYsQTU1sZj164YbN78KUhEhDMYugekikCCBg1CADt8fGyRkOAuBLt5MwuX");
            sb.Append("L6fj3LkUNDYm4NCheOzeHUufRWD16nAUF4vSsGcYhKUhj1D5yv6kqlERiNlXwRBARUyMK44e/RUvX+aivX0hHj6cj1u35uLKlQzo9angrBw+rMKePbHYsiUCa9YYQbhq");
            sb.Append("uHyDg+3h6moJGxt5s1wuzSIIiwGBWFhIK5YsCQFQhA8fCtHZmY+3b7V48SIXjx8vwJ0789DamomLF9U4dSoJdXWmICUlSuTn+0Gt9gIfRKl0gJubFWxtzdqozRcThMMX");
            sb.Append("QczNpRVlZZMEAOOzEN3dBXj3TkdZycOTJzm4e3cerl7NxIULqTh50jQja9dOxrJlShQU+CE93QtxcWMwYcKP8PS0gZ2dWTvF2EAQbv8LwgDl5T9/BGCAKURXVwFlRCdk");
            sb.Append("5NGjBbh92yhNY2MieUQleISlYZDly5UoKvJHZuY4zJo1BuHhjvD2/gEODub/kty/fdJLKE0VlZXRnwEQQQzSvHmjFTzy4MF8tLXNJbNmCGY9fjwBBw+KZmWQdesmo7Q0");
            sb.Append("FIsW+SMry1to81OmOIHNTpUD6j1/kWFjKSNSCQFsqK6e+UUAgzScDVEWoz9YlqYmNU6fTkZDwy+oqYlDZWUUyst/QlnZRCxeHCx01tRUT8EjYWEOJI01ewQE8QcD9JsB");
            sb.Append("BhCl0OL5c1EKrpKWlgycP59K5cpSGDPAUhgyoNH0kwH2wPr1Uz+bATbj+/c6vHr1sRnVJmbcunWQHmAALiXTKjDV/dmzhbh3LxvXr2vQ3MzpTkJ9vQpVVTOwbVukoDmb");
            sb.Append("r7CQq2CcSRXY2/dTBdwHtFq/XgA2XEdHPthwHPj+/WzcuKHBpUtpOHtW1HnvXmNgQ/mlpXkhNtYVoaFf2Qe4E8bHj6WmkyMEfv06D0+f5vQ5cRrOnOHAs7Fv3wxs3y6e");
            sb.Append("mAPrdKK5xE44qm8n1A24ExJA9fjxtkJvr6qKFRrOtWuaHmcn4ciR2SYnZrk4cN8xLc4C+aBngd4wjEpLlYKxuOXW15sGFk/sJywqfccy1fQ3T0NhHPM0ZIADB2b2msvQ");
            sb.Append("YrnXi6uaOP2GdB/gjciwkHDtGloqn5gDGzTm1WxYNiLeCcWVzF3YCQ2B1WrRXMO+E/JWzGnlnZAXDR6r0dEjuBUb7wVuQuCeC0o3vT8y9wK+GQUE2CMkRKzj73EzEq5k");
            sb.Append("dOLvczfk2zGNxewB7W/D8KX/ADrjG24Iit1hAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property RightYellow_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void RightYellow_Reset()
        {
            _RightYellow = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití RightYellow_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _RightYellow = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = GetUserAppDataPath(@"IconCache\Pictures");
                return __ImageCacheDir;
            }
        }
        private static string __ImageCacheDir;
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }

        /// <summary>
        /// Vrací adresář k datům aplikace, typicky: C:\Users\daj\AppData\Roaming\Asseco Solutions\TraceVisualiser
        /// Adresář neobsahuje verzi aplikace.
        /// </summary>
        public static string UserAppDataPath
        {
            get
            {
                System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.UserAppDataPath));          // Odstraním číslo verze !!!
                if (!di.Exists)
                    di.Create();
                return di.FullName;
            }
        }
        /// <summary>
        /// Metoda vrátí daný adresář (subPath) v rámci adresáře Steward.UserAppDataPath.
        /// Metoda zajistí, že daný adresář bude existovat.
        /// </summary>
        /// <param name="subPath"></param>
        /// <returns></returns>
        public static string GetUserAppDataPath(string subPath)
        {
            string path = System.IO.Path.Combine(UserAppDataPath, subPath);
            if (!System.IO.Directory.Exists(path))
                System.IO.Directory.CreateDirectory(path);
            return path;
        }
        #endregion
    }
}
